﻿using InterfaceJeu;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using ImplementationJeu;
using System.Collections.Generic;

namespace TestImplementation
{
    
    
    /// <summary>
    ///Classe de test pour UniteTest, destinée à contenir tous
    ///les tests unitaires UniteTest
    ///</summary>
    [TestClass()]
    public class UniteTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Obtient ou définit le contexte de test qui fournit
        ///des informations sur la série de tests active ainsi que ses fonctionnalités.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Attributs de tests supplémentaires
        // 
        //Vous pouvez utiliser les attributs supplémentaires suivants lorsque vous écrivez vos tests :
        //
        [ClassInitialize()]
        public static void MyClassInitialize(TestContext testContext)
        {
            ImplementationJeu.Jeu monJeu = ImplementationJeu.Jeu.Instance;
            InterfaceJeu.Joueur j1 = new ImplementationJeu.Joueur("Nicolas", System.Drawing.Color.Red, "INFO");
            InterfaceJeu.Joueur j2 = new ImplementationJeu.Joueur("Aurelien", System.Drawing.Color.Azure, "EII");
            List<InterfaceJeu.Joueur> lj = new List<InterfaceJeu.Joueur>();
            lj.Add(j1);
            lj.Add(j2);
            monJeu.demarrerNouveuJeu(lj, 25);
        }
        //Utilisez ClassInitialize pour exécuter du code avant d'exécuter le premier test dans la classe
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Utilisez ClassCleanup pour exécuter du code après que tous les tests ont été exécutés dans une classe
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Utilisez TestInitialize pour exécuter du code avant d'exécuter chaque test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Utilisez TestCleanup pour exécuter du code après que chaque test a été exécuté
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        internal virtual Unite CreateUnite()
        {
            Unite target = new EtudiantEII(ImplementationJeu.Jeu.Instance.Joueurs[0].civilisation,new ImplementationJeu.Coordonnees(15,15));
            ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(15,15)).unites.Add(target);
            return target;
        }

        /// <summary>
        ///Test pour estMorte
        ///</summary>
        [TestMethod()]
        public void estMorteTest()
        {
            Unite target = CreateUnite();
            bool expected = false;
            bool actual;
            actual = target.estMorte();
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour estMorte
        ///</summary>
        [TestMethod()]
        public void estMorteTest2()
        {
            Unite target = CreateUnite();
            bool expected = true;
            bool actual;
            target.pointDeVie = 0;
            actual = target.estMorte();
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour estMorte
        ///</summary>
        [TestMethod()]
        public void estMorteTest3()
        {
            Unite target = CreateUnite();
            bool expected = true;
            bool actual;
            target.mourrir();
            actual = target.estMorte();
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour joueUnTour
        ///</summary>
        [TestMethod()]
        public void joueUnTourTest()
        {
           Assert.Inconclusive("Ne peut être testée");
        }

        /// <summary>
        ///Test pour mourrir
        ///</summary>
        [TestMethod()]
        public void mourrirTest()
        {
            Unite target = CreateUnite();
            InterfaceJeu.Jeu monJeu = ImplementationJeu.Jeu.Instance;
            target.mourrir();
            Assert.IsFalse(monJeu.Carte.obtenirCase(target.position).unites.Contains(target));
            Assert.IsFalse(target.civil.unites.Contains(target));
            Assert.IsTrue(target.aEteUtilise);
            Assert.AreEqual(0, target.pointDeVie);
        }

        /// <summary>
        ///Test pour perdreVie
        ///</summary>
        [TestMethod()]
        public void perdreVieTest()
        {
            Unite target = CreateUnite();
            int vieAvant = target.pointDeVie;
            target.perdreVie();
            Assert.AreEqual(vieAvant-1,target.pointDeVie);
        }

        /// <summary>
        ///Test pour perdreVie
        ///</summary>
        [TestMethod()]
        public void perdreVieTest2()
        {
            Unite target = CreateUnite();
            target.pointDeVie = 0;
            int vieAvant = target.pointDeVie;
            target.perdreVie();
            Assert.AreEqual(vieAvant,target.pointDeVie);
        }

        /// <summary>
        ///Test pour recupererMouvement
        ///</summary>
        [TestMethod()]
        public void recupererMouvementTest()
        {
            Assert.Inconclusive("Se référer aux tests des implémentations");
        }

        /// <summary>
        ///Test pour recupererVie
        ///</summary>
        [TestMethod()]
        public void recupererVieTest()
        {
            Unite target = CreateUnite();
            int vieAvant = target.pointDeVie;
            target.recupererVie();
            Assert.AreEqual(vieAvant, target.pointDeVie);
        }

        /// <summary>
        ///Test pour recupererVie
        ///</summary>
        [TestMethod()]
        public void recupererVieTest2()
        {
            Unite target = CreateUnite();
            target.pointDeVie = 8;
            int vieAvant = target.pointDeVie;
            target.recupererVie();
            Assert.AreEqual(vieAvant+1, target.pointDeVie);
        }

        /// <summary>
        ///Test pour seDeplacer
        ///</summary>
        [TestMethod()]
        public void seDeplacerTest()
        {
            Unite target = CreateUnite();
            ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(15, 15)).unites.Add(target);
            Case c = ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(17,17));
            target.seDeplacer(c);
            Assert.AreEqual(c.coordo, target.position);
        }

        /// <summary>
        ///Test pour seDeplacer
        ///</summary>
        [TestMethod()]
        public void seDeplacerTest2()
        {
            Unite target = CreateUnite();
            ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(15, 15)).unites.Add(target);
            Case c = ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(17, 17));
            Unite inconnue = CreateUnite();
            ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(17, 17)).unites.Add(inconnue);
            target.seDeplacer(c);
            Assert.AreEqual(c.coordo, target.position);
        }

        /// <summary>
        ///Test pour seDeplacer
        ///</summary>
        [TestMethod()]
        public void seDeplacerTest3()
        {
            Unite target = CreateUnite();
            ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(15, 15)).unites.Add(target);
            Case c = ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(17, 17));
            Unite inconnue = new EtudiantINFO(ImplementationJeu.Jeu.Instance.Joueurs[1].civilisation,new ImplementationJeu.Coordonnees(17,17));
            c.unites.Clear();
            c.unites.Add(inconnue);
            target.seDeplacer(c);
            Assert.IsTrue(c.coordo != target.position);
        }

        /// <summary>
        ///Test pour seDeplacer
        ///</summary>
        [TestMethod()]
        public void seDeplacerTest4()
        {
            Unite target = CreateUnite();
            ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(15, 15)).unites.Add(target);
            Case c = ImplementationJeu.Jeu.Instance.Carte.obtenirCase(new ImplementationJeu.Coordonnees(22, 22));
            target.seDeplacer(c);
            Assert.AreNotEqual(c.coordo, target.position);
        }

        /// <summary>
        ///Test pour seRestaureApresUnTour
        ///</summary>
        [TestMethod()]
        public void seRestaureApresUnTourTest()
        {
            Unite target = CreateUnite();            
            target.pointDeVie = 5;
            target.aEteUtilise = false;

            int vieAvant = target.pointDeVie;
            int nbMouvAvant = target.nbMouvement;

            target.nbMouvement = 0;

            target.seRestaureApresUnTour();

            Assert.AreEqual(vieAvant + 1, target.pointDeVie);
            Assert.AreEqual(nbMouvAvant, target.nbMouvement);
        }

        /// <summary>
        ///Test pour seRestaureApresUnTour
        ///</summary>
        [TestMethod()]
        public void seRestaureApresUnTourTest2()
        {
            Unite target = CreateUnite();
            target.pointDeVie = 5;
            target.aEteUtilise = true;

            int vieAvant = target.pointDeVie;
            int nbMouvAvant = target.nbMouvement;

            target.nbMouvement = 0;

            target.seRestaureApresUnTour();

            Assert.AreEqual(vieAvant, target.pointDeVie);
            Assert.AreEqual(nbMouvAvant, target.nbMouvement);
            Assert.IsFalse(target.aEteUtilise);
        }

        /// <summary>
        ///Test pour seRestaureApresUnTour
        ///</summary>
        [TestMethod()]
        public void seRestaureApresUnTourTest3()
        {
            Unite target = CreateUnite();
            target.mourrir();

            int vieAvant = target.pointDeVie;
            int nbMouvAvant = target.nbMouvement;

            target.nbMouvement = 0;

            target.seRestaureApresUnTour();

            Assert.AreEqual(vieAvant, target.pointDeVie);
            Assert.AreEqual(nbMouvAvant, target.nbMouvement);
            Assert.IsTrue(target.aEteUtilise);
        }

        /// <summary>
        ///Test pour aEteUtilise
        ///</summary>
        [TestMethod()]
        public void aEteUtiliseTest()
        {
            Unite target = CreateUnite();
            bool expected = false;
            bool actual;
            target.aEteUtilise = expected;
            actual = target.aEteUtilise;
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour nbMouvement
        ///</summary>
        [TestMethod()]
        public void nbMouvementTest()
        {
            Unite target = CreateUnite();
            int expected = 0;
            int actual;
            target.nbMouvement = expected;
            actual = target.nbMouvement;
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour pointAttaque
        ///</summary>
        [TestMethod()]
        public void pointAttaqueTest()
        {
            Unite target = CreateUnite();
            int expected = 0; 
            int actual;
            target.pointAttaque = expected;
            actual = target.pointAttaque;
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour pointDeVie
        ///</summary>
        [TestMethod()]
        public void pointDeVieTest()
        {
            Unite target = CreateUnite();
            int expected = 0;
            int actual;
            target.pointDeVie = expected;
            actual = target.pointDeVie;
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour pointDefense
        ///</summary>
        [TestMethod()]
        public void pointDefenseTest()
        {
            Unite target = CreateUnite(); 
            int expected = 0;
            int actual;
            target.pointDefense = expected;
            actual = target.pointDefense;
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour position
        ///</summary>
        [TestMethod()]
        public void positionTest()
        {
            Unite target = CreateUnite();
            InterfaceJeu.Coordonnees expected = new ImplementationJeu.Coordonnees(10, 10);
            InterfaceJeu.Coordonnees actual;
            target.position = expected;
            actual = target.position;
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour vieMax
        ///</summary>
        [TestMethod()]
        public void vieMaxTest()
        {
            Unite target = CreateUnite();
            int expected = 10; 
            int actual;
            target.vieMax = expected;
            actual = target.vieMax;
            Assert.AreEqual(expected, actual);
        }
    }
}
